Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@mpt_api_client/models/model.py`:
- Around line 177-183: The Model.__init__ currently mutates the caller's
resource_data dict and allows payload keys like "meta" or "resource_data" to
collide with constructor params; to fix, make a new dict copy for merging (e.g.,
data = dict(resource_data) if resource_data else {}) so the caller's object is
not modified, then check kwargs for reserved names ("meta", "resource_data") and
either remove them or raise a clear TypeError to prevent silent argument binding
collisions, finally update the new data dict with kwargs and call
super().__init__(**data); reference the __init__ method, the "meta" and
"resource_data" keys, and the Model constructor when applying this change.

---

Nitpick comments:
In `@tests/unit/models/resource/test_resource.py`:
- Around line 143-156: The test test_overwritting_as_object is claiming to test
object-assignment but still assigns a dict to agreement.parameters.ordering[1];
change the assignment to instantiate and assign an actual parameter-item object
instead of a dict (e.g., create an instance of the ordering item class used by
AgreementDummy or the model class that represents ordering entries) so the code
path for object replacement is exercised; update the assignment target
agreement.parameters.ordering[1] to use that instantiated object and adjust any
assertions if needed to compare object attributes rather than raw dicts.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@mpt_api_client/models/model.py`:
- Around line 140-164: The _process_value method in BaseModel is too complex;
extract the dict and list branches into small helpers: implement a
_process_dict_value(self, value: dict, target_class: Any) -> Any that contains
the dict-to-BaseModel logic (use target_class if issubclass(BaseModel) else
BaseModel), a _resolve_list_model_class(self, target_class: Any) ->
Type[BaseModel] that encapsulates get_origin/get_args logic to pick the element
model, and a _process_list_value(self, value: Iterable, target_class: Any) ->
ModelList that calls _resolve_list_model_class and returns ModelList(value,
model_class=...), then replace the dict/list blocks in _process_value with calls
to these helpers so functionality (including checks for BaseModel, ModelList,
UserList) remains identical but cognitive complexity is reduced.

---

Duplicate comments:
In `@mpt_api_client/models/model.py`:
- Around line 177-183: Model.new and Model.__init__ currently allow payload
splatting to collide with reserved params (meta, resource_data) and mutate
caller-owned resource_data when merging kwargs; fix by defensively copying and
validating inputs: in Model.__init__ (and in Model.new) make a shallow copy of
the incoming resource_data (use a new dict) before merging, explicitly disallow
or raise if kwargs contain reserved keys ("meta" or "resource_data") to prevent
collisions, and perform the merge into the new copy rather than mutating the
caller's dict; update Model.new to filter/validate its payload before forwarding
to Model.__init__ (or call __init__ with explicit args) so reserved params
cannot be overwritten.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@mpt_api_client/models/model.py`:
- Around line 14-24: The acronym regex _SNAKE_CASE_ACRONYM should not use an
atomic group because it blocks backtracking and breaks conversions like
"IPAddress" and "HTTPServerError"; replace its definition with a plain capturing
pattern such as re.compile(r"([A-Z]+)([A-Z][a-z0-9])") so to_snake_case's
subsequent substitution _SNAKE_CASE_ACRONYM.sub(r"\1_\2", snake) correctly
inserts underscores between acronym runs and the following capitalized word (no
other changes to to_snake_case or the substitution logic required).

---

Duplicate comments:
In `@mpt_api_client/models/model.py`:
- Around line 140-164: Refactor _process_value by moving the dict and list
handling into small helpers: create _process_dict_value(value, target_class) to
encapsulate the dict->BaseModel logic (including the issubclass check and
returning target_class(**value) or BaseModel(**value), and create
_resolve_list_model_class(target_class) to return the element model_class
(default BaseModel) by inspecting get_origin/get_args, and
_process_list_value(value, target_class) to call that resolver and return
ModelList(value, model_class=model_class); then make _process_value simply
dispatch to these helpers (dict -> _process_dict_value, list/UserList ->
_process_list_value, else return value) so branching is isolated into the new
functions while preserving existing behavior and using the same symbols:
_process_value, _process_dict_value, _process_list_value,
_resolve_list_model_class, BaseModel, ModelList.

---

Nitpick comments:
In `@tests/unit/models/resource/test_resource.py`:
- Around line 143-160: Rename the test and change the mutation to exercise the
object-style path: in test_overwritting_as_object (or better
test_overwriting_as_object) instead of assigning a dict to
agreement.parameters.ordering[1], mutate the attribute on the item object (e.g.,
agreement.parameters.ordering[1].value = "Springfield" or change
.external_id/.value as appropriate) so you exercise the object-mutation code
path on AgreementDummy and its nested list; keep assertions for agreement.id and
the ordering items' attributes (use .external_id/.value accessors) and ensure
agreement.to_dict() still equals the original agreement_data after the object
mutation.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@mpt_api_client/models/model.py`:
- Line 5: The import of typing.override in mpt_api_client/models/model.py will
fail on Python 3.12; replace it with a conditional/fallback import so older
Pythons use typing_extensions.override (or import override from typing when
available) — update the import line that currently references "override"
alongside "Any, ClassVar, Self, get_args, get_origin" to try importing override
from typing_extensions first (or fall back to typing for 3.13+), and ensure
packaging includes typing-extensions if you choose the stable dependency route.
- Around line 69-70: The BaseModel class is annotated with `@dataclass` which
auto-generates __eq__ for zero fields causing all BaseModel instances to compare
equal; update the class declaration to disable dataclass equality (e.g., change
`@dataclass` to `@dataclass`(eq=False)) or remove the `@dataclass` decorator entirely,
ensuring existing dynamic attribute handling via object.__setattr__ remains
unchanged; adjust any imports/usages if you remove the decorator and run tests
focusing on BaseModel, _process_value, and places that instantiate BaseModel to
confirm equality semantics are fixed.

In `@tests/unit/models/resource/test_resource.py`:
- Around line 143-160: The test test_overwritting_as_object is supposed to
exercise replacing an ordering element with an object but currently assigns a
dict (duplicating test_overwritting); change the assignment to instantiate the
same element class as the existing item instead of a plain dict. For example,
replace the line agreement.parameters.ordering[1] = {"externalId": "address",
"value": "Springfield"} with something that constructs the same type as
agreement.parameters.ordering[1] (e.g. agreement.parameters.ordering[1] =
type(agreement.parameters.ordering[1])("address", "Springfield") or use the
appropriate constructor/class for parameter items) so the test uses object
reassignment while keeping the rest of assertions and AgreementDummy usage
intact.

---

Outside diff comments:
In `@mpt_api_client/models/model.py`:
- Around line 205-207: The code calls response_data.get(cls._data_key) when
cls._data_key is set, which will raise AttributeError if response_data is not a
dict; update the block in the class method that handles response_data so you
first check isinstance(response_data, dict) before attempting
response_data.get(...), and if it's not a dict raise the intended TypeError (or
handle None appropriately) with a clear message; change the logic around the
symbols cls._data_key and response_data to perform the type guard prior to
extraction and preserve existing behavior when the key is missing.

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@mpt_api_client/models/model.py`:
- Around line 69-70: The BaseModel is decorated with `@dataclass` which generates
an automatic __eq__ that can produce incorrect comparisons for instances with
dynamic attributes; change the decorator to `@dataclass`(eq=False) (or remove the
dataclass decorator) on the BaseModel class declaration so dataclass-generated
equality is disabled for BaseModel (locate the class by the symbol BaseModel and
the decorator `@dataclass` and update it to `@dataclass`(eq=False) to prevent
false-equal comparisons).

In `@tests/unit/models/resource/test_resource.py`:
- Around line 143-160: The test test_overwritting_as_object currently reassigns
agreement.parameters.ordering[1] to a dict (duplicating test_overwritting);
update it to reassign with an actual object instance that mimics the resource
wrapper (e.g., construct the same type used for items in ordering or a simple
object with attributes external_id and value) so the object-path mutation is
exercised; keep assertions (agreement.id,
agreement.parameters.ordering[0].external_id,
agreement.parameters.ordering[1].external_id and agreement.to_dict()) the same
to verify the object assignment round-trips, and use AgreementDummy /
agreement.parameters.ordering to locate the change.